home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / comm / bbs / s342q16.lha / popular.c < prev    next >
C/C++ Source or Header  |  1996-08-29  |  8KB  |  340 lines
  1. /*
  2.  *                popular.c
  3.  *
  4.  * Rough popularity estimator for rooms.
  5.  */
  6.  
  7. #include "ctdl.h"
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <stdlib.h>
  11. #include <math.h>
  12. #include <ctype.h>
  13. #include <time.h>
  14. #include <proto/exec.h>
  15. #include <dos/dos.h>
  16. #include <pragmas/dos_pragmas.h>
  17. #include "exec/memory.h"
  18. #include "exec/ports.h"
  19. #include "exec/exec.h"
  20.  
  21. /*
  22.  *                history
  23.  *
  24.  * 90Apr27 HAW  Version 2.3 - sorted output.
  25.  * 89Oct13 HAW  Version 2.2.
  26.  * 86May12 HAW  Version 2.1.
  27.  * 86Apr?? HAW  Version 2.0.
  28.  * 86Apr07 HAW  Version 1.1.
  29.  * 86Apr01 HAW  Created.
  30.  */
  31.  
  32. /*
  33.  *                contents
  34.  *
  35.  *    crashout()        irrecoverable error
  36.  *    main()            Main controller for this program
  37.  */
  38. int  mPrintf(char *format, ...) {return 0; }  /* stub to quiet the linker */
  39.  
  40. #define LINE \
  41. "------------------------------------------------------------------------------"
  42.  
  43. struct counts {
  44.     int  forgot, num;
  45.     int  messages;
  46.     long bytes;
  47. } *countTab;
  48.  
  49. int    messFlag = FALSE;
  50. extern MessageBuffer  msgBuf; /* The -sole- message buffer    */
  51. extern FILE *msgfl, *msgfl2;
  52. extern FILE *upfd;  /* file descriptor for the msg file    */
  53. int PublicRoomCount = 0, ForgetCount = 0;
  54. int activeLogs = 0, activeForgots = 0;
  55.  
  56. extern rTable *roomTab;    /* RAM index of rooms    */
  57. extern aRoom  roomBuf;    /* room buffer    */
  58. extern FILE    *roomfl;    /* file descriptor for rooms    */
  59. extern int    thisRoom;    /* room currently in roomBuf    */
  60. extern logBuffer logBuf;    /* Log buffer of a person    */
  61. extern int    thisLog;    /* entry currently in logBuf    */
  62. extern FILE    *logfl;    /* log file descriptor    */
  63. extern CONFIG    cfg;    /* A buncha variables    */
  64.  
  65. void getCUdate(int *year, char **month, int *day, int *hours, int *minutes);
  66. void flags(int argc, char *argv[]);
  67. int mulchAcct(void);
  68. void doMessages(void);
  69. void display(void);
  70. void handle(void);
  71.  
  72. /*
  73.  * crashout()
  74.  *
  75.  * This handles the irrecoverable error.
  76.  */
  77. void crashout(str)
  78. char *str;
  79. {
  80.     exit(printf(str));
  81. }
  82.  
  83. /*
  84.  * display()
  85.  *
  86.  * This function displays the results.
  87.  */
  88. void display()
  89. {
  90.     int rover;
  91.     void ShowIt();
  92.     int year, day, hours, minutes;
  93.     char *month;
  94.     int numcmp();
  95.     static SListBase Sorted = { NULL, NULL, numcmp, NoFree, NULL };
  96.  
  97.  
  98.     for (rover = 0;  rover < MAXROOMS;  rover++)
  99.     if (roomTab[rover].rtflags.INUSE != 0 &&
  100.         roomTab[rover].rtflags.PUBLIC != 0) {
  101.         AddData(&Sorted, countTab + rover, NULL, FALSE);
  102.         countTab[rover].num = rover;
  103.     }
  104.  
  105.     getCUdate(&year, &month, &day, &hours, &minutes);
  106.     printf("%d%s%02d @ %d:%02d\n\n", year, month, day, hours, minutes);
  107.  
  108.     printf(
  109. "Out of a log of %d entries, %d are in use; %d (%d%%) have used <Z>Forget.\n\n",
  110.  cfg.MAXLOGTAB, activeLogs, activeForgots, (100* activeForgots) / activeLogs);
  111.  
  112.     printf("%48s%15s\n", "Total", "Forgotten");
  113.     printf("%-25s%-15s%-13s%s", "Room name", "# Forgotten", "Percentage",
  114.                             "Percentage");
  115.     if (messFlag) printf("%10s", "Messages");
  116.     printf("\n%s\n", LINE);
  117.  
  118.     RunList(&Sorted, ShowIt);
  119.  
  120.     ForgetCount /= PublicRoomCount;
  121.     printf("%s\n\n", LINE);
  122.     printf("There are %d public rooms, ", PublicRoomCount);
  123.     printf("an average %d forgetting them (%d%% and %d%%)\n\n",
  124.                             ForgetCount,
  125.     (activeLogs != 0) ? (100 * ForgetCount) / activeLogs : 0,
  126.     (activeForgots != 0) ? (100 * ForgetCount) / activeForgots : 0);
  127. }
  128.  
  129. /*
  130.  * numcmp()
  131.  *
  132.  * This function will compare two counts and return who's higher.  This is
  133.  * used in list sorting.
  134.  */
  135. int numcmp(struct counts *s, struct counts *d)
  136. {
  137.     return d->forgot - s->forgot;
  138. }
  139.  
  140. /*
  141.  * ShowIt()
  142.  *
  143.  * This will show a room with forgotten stats.  This is used in list handling.
  144.  */
  145. void ShowIt(struct counts *s)
  146. {
  147.     PublicRoomCount++;
  148.     ForgetCount += s->forgot;
  149.     printf("%-30s%-15d%-9d%3d", roomTab[s->num].rtname,
  150.                             s->forgot,
  151.    (activeLogs != 0) ? (100 * s->forgot) / activeLogs : 0,
  152.    (activeForgots != 0) ? (100 * s->forgot) / activeForgots : 0);
  153.     if (messFlag) printf("%11d (%ld)", s->messages,
  154.         (s->messages == 0) ? 0 : s->bytes / (long) s->messages);
  155.     printf("\n");
  156. }
  157.  
  158. /*
  159.  * doMessages()
  160.  *
  161.  * This function loops thru the msg file until finished.  It accumulates
  162.  * statistics, etc.
  163.  */
  164. void doMessages()
  165. {
  166.     MSG_NUMBER msg, firstMessage;
  167.     MSG_NUMBER total;    /* For stat keeping. */
  168.     extern struct mBuf mFile1;
  169.  
  170.     fprintf(stderr, "Mulching...\n");
  171.     InitMsgBase();
  172.     startAt(msgfl, &mFile1, 0, 0);
  173.     getMessage(getMsgChar, FALSE, TRUE, TRUE);
  174.     msg = atol(msgBuf.mbId);
  175.     fprintf(stderr, "%ld\n", msg);
  176.     firstMessage = msg;
  177.     handle();
  178.     getMessage(getMsgChar, FALSE, TRUE, TRUE);
  179.     msg = atol(msgBuf.mbId);
  180.     total = 1;
  181.     while (msg != firstMessage) {
  182.     total++;
  183.     fprintf(stderr, "%ld\r", msg);
  184.     handle();
  185.     getMessage(getMsgChar, FALSE, TRUE, TRUE);
  186.     msg = atol(msgBuf.mbId);
  187.     }
  188. }
  189.  
  190. /*
  191.  * flags()
  192.  *
  193.  * This function analyzes the command line arguments.  Very primitive.
  194.  */
  195. void flags(argc, argv)
  196. int argc;
  197. char *argv[];
  198. {
  199.     int i;
  200.  
  201.     for (i = 0; i < MAXROOMS; i++) {
  202.     countTab[i].forgot = 0;
  203.     countTab[i].messages = 0;
  204.     }
  205.  
  206.     while (argc != 1) {
  207.     argc--;
  208.     if (strCmpU("-M", argv[argc]) == 0)
  209.         messFlag = TRUE;
  210.     }
  211. }
  212.  
  213. /*
  214.  * getCUdate()
  215.  *
  216.  * This function retrieves the system date and returns in the parameters.
  217.  */
  218. void getCUdate(year, month, day, hours, minutes)
  219. int *year, *day, *hours, *minutes;
  220. char **month;
  221. {
  222.     int m;
  223.     static char *monthTab[13] = {"", "Jan", "Feb", "Mar",
  224.                 "Apr", "May", "Jun",
  225.                 "Jul", "Aug", "Sep",
  226.                 "Oct", "Nov", "Dec" };
  227.  
  228.     getUtilDate(year, &m, day, hours, minutes);
  229.     *month = monthTab[m];
  230.     *year -= 1900;
  231. }
  232.  
  233. /*
  234.  * handle()
  235.  *
  236.  * This function searches the room base for the current msg's room, increments
  237.  * the appropriate counters when found.
  238.  */
  239. void handle()
  240. {
  241.     int rover;
  242.     int MsgLen(void);
  243.  
  244.     for (rover = 0; rover < MAXROOMS; rover++)
  245.     if (strCmpU(roomTab[rover].rtname, msgBuf.mbroom) == 0) {
  246.         countTab[rover].messages++;
  247.         countTab[rover].bytes += MsgLen();
  248.         break;
  249.     }
  250. }
  251.  
  252. /*
  253.  * MsgLen()
  254.  *
  255.  * This function figures out the byte usage of the message.
  256.  */
  257. int MsgLen()
  258. {
  259.     return  (int) (    strLen(msgBuf.mbtext)  + strLen(msgBuf.mbauth) +
  260.                     strLen(msgBuf.mbdate)  + strLen(msgBuf.mbtime) +
  261.                     strLen(msgBuf.mbId)    + strLen(msgBuf.mboname) +
  262.                     strLen(msgBuf.mborig)  + strLen(msgBuf.mbroom) +
  263.                     strLen(msgBuf.mbsrcId) + strLen(msgBuf.mbto) +
  264.                     strLen(msgBuf.mbaddr)  + strLen(msgBuf.mbOther) );
  265. }
  266.  
  267. /*
  268.  * main()
  269.  *
  270.  * This is the main controller.
  271.  */
  272. int main(int, char **);
  273. int main(argc, argv)
  274. int argc;
  275. char *argv[];
  276. {
  277.     SYS_FILE temp;
  278.     int Index;
  279.  
  280.     cfg.weAre = UTILITY;
  281.     printf("\nRoom Popularity Estimator (Version 3.41)\n%s\n", COPYRIGHT);
  282.     fprintf(stderr, "Munching...\n");
  283.     printf("\n");
  284.     if (readSysTab(FALSE, TRUE)) {
  285.     initRoomBuf(&roomBuf);
  286.     countTab = (struct counts *) GetDynamic(MAXROOMS * sizeof *countTab);
  287.     flags(argc, argv);
  288.     mvToHomeDisk(&cfg.homeArea);
  289.     makeSysName(temp, "ctdlroom.sys", &cfg.roomArea);
  290.     openFile(temp, &roomfl);
  291.     makeSysName(temp, "ctdllog.sys", &cfg.logArea);
  292.     openFile(temp, &logfl);
  293.     initLogBuf(&logBuf);
  294.  
  295.     for (Index = 0; Index < cfg.MAXLOGTAB; Index++) {
  296.         getLog(&logBuf, Index);
  297.         if (logBuf.lbflags.L_INUSE) {
  298.         activeLogs++;
  299.         activeForgots += mulchAcct();
  300.         }
  301.         fprintf(stderr, "%d\r", Index);
  302.     }
  303.  
  304.     if (messFlag)
  305.         doMessages();
  306.  
  307.     display();
  308.     }
  309.     return 0;
  310. }
  311.  
  312. /*
  313.  * mulchAcct()
  314.  *
  315.  * This goes through all the rooms, checking them against the current acct
  316.  * for statistics gathering.
  317.  */
  318. int mulchAcct()
  319. {
  320.     int i, j, g, usedForget;
  321.  
  322.     usedForget = 0;
  323.     for (i = 0;  i < MAXROOMS;  i++) {
  324.     if (roomTab[i].rtflags.PUBLIC != 0) {
  325.         if ((logBuf.lbgen[i] >> GENSHIFT) != roomTab[i].rtgen)  {
  326.         j = roomTab[i].rtgen - (logBuf.lbgen[i] >> GENSHIFT);
  327.         if (j < 0)
  328.             g = -j;
  329.         else
  330.             g = j;
  331.         if (g == FORGET_OFFSET) {
  332.             usedForget = 1;
  333.             countTab[i].forgot++;
  334.         }
  335.         }
  336.     }
  337.     }
  338.     return usedForget;
  339. }
  340.